---
title: "内存管理和性能优化 - ARC、值类型"
description: "学习 Swift 内存管理：ARC、值类型、性能优化，与 JavaScript 垃圾回收对比"
---

# 内存管理和性能优化：ARC、值类型

在本模块中，我们探索 Swift 的内存管理系统，包括自动引用计数（ARC）、值类型、性能优化技术和分析工具。我们将这些方法与 JavaScript 的垃圾回收和优化策略进行对比。

## 目录
- [介绍：内存管理模型](#介绍内存管理模型)
- [自动引用计数（ARC）](#自动引用计数arc)
- [值类型 vs 引用类型](#值类型-vs-引用类型)
- [内存安全](#内存安全)
- [性能优化](#性能优化)
- [分析和分析](#分析和分析)
- [高级内存管理](#高级内存管理)
- [练习题](#练习题)
- [关键要点](#关键要点)

## 介绍：内存管理模型

Swift 和 JavaScript 使用根本不同的内存管理方法，每种方法都有其自身的优势和权衡。

| 特性               | JavaScript | Swift |
|--------------------|------------|-------|
| 内存管理           | 垃圾回收   | ARC   |
| 内存安全           | 运行时     | 编译时 |
| 性能可预测性       | 可变       | 可预测 |
| 内存泄漏           | 可能       | 预防   |
| 值类型             | 有限       | 完全支持 |
| 引用计数           | 否         | 是    |
| 编译时检查         | 否         | 是    |

## 自动引用计数（ARC）

Swift 的 ARC 通过跟踪对象的引用来自动管理内存，当不再需要时释放它们。

<UniversalEditor title="ARC vs 垃圾回收" compare={true}>
```javascript !! js
// JavaScript：垃圾回收
class User {
    constructor(name, email) {
        this.name = name;
        this.email = email;
        this.friends = [];
    }
    
    addFriend(friend) {
        this.friends.push(friend);
        friend.friends.push(this); // 潜在的循环引用
    }
    
    removeFriend(friend) {
        const index = this.friends.indexOf(friend);
        if (index > -1) {
            this.friends.splice(index, 1);
        }
    }
}

// 循环引用示例
const user1 = new User("张三", "zhang@example.com");
const user2 = new User("李四", "li@example.com");

user1.addFriend(user2);
user2.addFriend(user1);

// 内存泄漏潜在风险 - 循环引用
// 垃圾回收器可能不会立即清理
console.log("创建了具有潜在内存泄漏的用户");

// 需要手动清理
user1.removeFriend(user2);
user2.removeFriend(user1);

// 变量可以设置为 null 来帮助 GC
user1 = null;
user2 = null;
```

```swift !! swift
// Swift：自动引用计数
class User {
    let name: String
    let email: String
    var friends: [User] = []
    
    init(name: String, email: String) {
        self.name = name
        self.email = email
    }
    
    func addFriend(_ friend: User) {
        friends.append(friend)
        friend.friends.append(self) // ARC 处理循环引用
    }
    
    func removeFriend(_ friend: User) {
        if let index = friends.firstIndex(where: { $0 === friend }) {
            friends.remove(at: index)
        }
    }
    
    deinit {
        print("用户 \(name) 正在被释放")
    }
}

// ARC 自动管理内存
var user1: User? = User(name: "张三", email: "zhang@example.com")
var user2: User? = User(name: "李四", email: "li@example.com")

user1?.addFriend(user2!)
user2?.addFriend(user1!)

print("创建了具有 ARC 管理的用户")

// ARC 在引用被移除时自动释放
user1 = nil
user2 = nil

// 输出："用户 张三 正在被释放"
// 输出："用户 李四 正在被释放"
```
</UniversalEditor>

### 强引用、弱引用和无主引用

<UniversalEditor title="引用类型" compare={true}>
```javascript !! js
// JavaScript：手动引用管理
class Parent {
    constructor(name) {
        this.name = name;
        this.children = [];
    }
    
    addChild(child) {
        this.children.push(child);
        child.parent = this; // 强引用 - 潜在内存泄漏
    }
    
    removeChild(child) {
        const index = this.children.indexOf(child);
        if (index > -1) {
            this.children.splice(index, 1);
            child.parent = null; // 手动清理
        }
    }
}

class Child {
    constructor(name) {
        this.name = name;
        this.parent = null;
    }
}

// 内存泄漏示例
const parent = new Parent("王五");
const child = new Child("小王");

parent.addChild(child);

// 创建了循环引用
console.log("父级有子级:", parent.children.length);
console.log("子级有父级:", child.parent.name);

// 需要手动清理
parent.removeChild(child);
parent = null;
child = null;
```

```swift !! swift
// Swift：强引用、弱引用和无主引用
class Parent {
    let name: String
    var children: [Child] = []
    
    init(name: String) {
        self.name = name
    }
    
    func addChild(_ child: Child) {
        children.append(child)
        child.parent = self // 强引用
    }
    
    func removeChild(_ child: Child) {
        if let index = children.firstIndex(where: { $0 === child }) {
            children.remove(at: index)
            child.parent = nil
        }
    }
    
    deinit {
        print("父级 \(name) 正在被释放")
    }
}

class Child {
    let name: String
    weak var parent: Parent? // 弱引用 - 防止循环引用
    
    init(name: String) {
        self.name = name
    }
    
    deinit {
        print("子级 \(name) 正在被释放")
    }
}

// ARC 自动处理弱引用
var parent: Parent? = Parent(name: "王五")
var child: Child? = Child(name: "小王")

parent?.addChild(child!)

print("父级有子级:", parent?.children.count ?? 0)
print("子级有父级:", child?.parent?.name ?? "无")

// 弱引用的自动清理
parent = nil
child = nil

// 输出："父级 王五 正在被释放"
// 输出："子级 小王 正在被释放"
```
</UniversalEditor>

## 值类型 vs 引用类型

Swift 的值类型提供可预测的性能并消除许多内存管理问题。

<UniversalEditor title="值类型 vs 引用类型" compare={true}>
```javascript !! js
// JavaScript：原始类型和对象引用
// 原始类型（值语义）
let number1 = 42;
let number2 = number1;
number2 = 100;
console.log("number1:", number1); // 42（未改变）
console.log("number2:", number2); // 100

// 对象类型（引用语义）
let person1 = { name: "张三", age: 30 };
let person2 = person1;
person2.age = 31;
console.log("person1.age:", person1.age); // 31（已改变）
console.log("person2.age:", person2.age); // 31

// 数组（引用语义）
let array1 = [1, 2, 3];
let array2 = array1;
array2.push(4);
console.log("array1:", array1); // [1, 2, 3, 4]（已改变）
console.log("array2:", array2); // [1, 2, 3, 4]

// 手动复制以实现值语义
let person3 = { ...person1 }; // 浅拷贝
person3.age = 32;
console.log("person1.age:", person1.age); // 31（未改变）
console.log("person3.age:", person3.age); // 32

// 深拷贝需要手动实现
function deepCopy(obj) {
    return JSON.parse(JSON.stringify(obj));
}

let deepPerson = deepCopy(person1);
deepPerson.age = 33;
console.log("person1.age:", person1.age); // 31（未改变）
console.log("deepPerson.age:", deepPerson.age); // 33
```

```swift !! swift
// Swift：值类型和引用类型
// 值类型（结构体、枚举、原始类型）
struct Person {
    var name: String
    var age: Int
}

var person1 = Person(name: "张三", age: 30)
var person2 = person1
person2.age = 31

print("person1.age:", person1.age) // 30（未改变）
print("person2.age:", person2.age) // 31

// 数组（Swift 中的值类型）
var array1 = [1, 2, 3]
var array2 = array1
array2.append(4)

print("array1:", array1) // [1, 2, 3]（未改变）
print("array2:", array2) // [1, 2, 3, 4]

// 引用类型（类）
class User {
    var name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

var user1 = User(name: "李四", age: 25)
var user2 = user1
user2.age = 26

print("user1.age:", user1.age) // 26（已改变）
print("user2.age:", user2.age) // 26

// 值类型的自动复制
let person3 = person1 // 自动复制
person3.age = 32
print("person1.age:", person1.age) // 30（未改变）
print("person3.age:", person3.age) // 32
```
</UniversalEditor>

### 写时复制优化

<UniversalEditor title="写时复制" compare={true}>
```javascript !! js
// JavaScript：无内置写时复制优化
class OptimizedArray {
    constructor() {
        this.data = [];
        this.referenceCount = 1;
    }
    
    // 手动写时复制实现
    copy() {
        if (this.referenceCount > 1) {
            // 当存在多个引用时创建新副本
            const newArray = new OptimizedArray();
            newArray.data = [...this.data];
            newArray.referenceCount = 1;
            this.referenceCount--;
            return newArray;
        } else {
            // 当只有一个引用时共享引用
            this.referenceCount++;
            return this;
        }
    }
    
    push(item) {
        if (this.referenceCount > 1) {
            // 修改前创建副本
            const copy = this.copy();
            copy.data.push(item);
            return copy;
        } else {
            this.data.push(item);
            return this;
        }
    }
    
    get length() {
        return this.data.length;
    }
}

// 使用示例
const array1 = new OptimizedArray();
array1.push(1);
array1.push(2);

const array2 = array1.copy(); // 共享引用
console.log("array1 length:", array1.length); // 2
console.log("array2 length:", array2.length); // 2

const array3 = array2.push(3); // 创建副本
console.log("array2 length:", array2.length); // 2（未改变）
console.log("array3 length:", array3.length); // 3
```

```swift !! swift
// Swift：内置写时复制优化
var array1 = [1, 2, 3, 4, 5]
var array2 = array1 // 尚未复制 - 共享引用

print("array1 地址:", Unmanaged.passUnretained(array1 as AnyObject).toOpaque())
print("array2 地址:", Unmanaged.passUnretained(array2 as AnyObject).toOpaque())

// 相同地址 - 共享引用
array2.append(6) // 写时复制在此触发

print("修改后:")
print("array1:", array1) // [1, 2, 3, 4, 5]（未改变）
print("array2:", array2) // [1, 2, 3, 4, 5, 6]

// 自定义写时复制实现
struct OptimizedData {
    private var _data: [Int]
    private var _copyOnWrite: Bool = false
    
    init(_ data: [Int]) {
        self._data = data
    }
    
    mutating func append(_ value: Int) {
        if _copyOnWrite {
            _data = _data + [value]
            _copyOnWrite = false
        } else {
            _data.append(value)
        }
    }
    
    var count: Int {
        return _data.count
    }
    
    var data: [Int] {
        mutating get {
            _copyOnWrite = true
            return _data
        }
    }
}

var data1 = OptimizedData([1, 2, 3])
var data2 = data1

print("修改前:")
print("data1 count:", data1.count)
print("data2 count:", data2.count)

data2.append(4)

print("修改后:")
print("data1 count:", data1.count) // 3（未改变）
print("data2 count:", data2.count) // 4
```
</UniversalEditor> 

## 内存安全

Swift 提供编译时内存安全保证，防止常见的内存相关错误。

<UniversalEditor title="内存安全" compare={true}>
```javascript !! js
// JavaScript：运行时内存安全
class UnsafeArray {
    constructor() {
        this.data = [];
    }
    
    set(index, value) {
        // 无边界检查 - 潜在的运行时错误
        this.data[index] = value;
    }
    
    get(index) {
        // 无边界检查 - 如果越界返回 undefined
        return this.data[index];
    }
    
    remove(index) {
        // 无边界检查 - 可能导致问题
        this.data.splice(index, 1);
    }
}

const unsafeArray = new UnsafeArray();

// 可能的运行时错误
try {
    unsafeArray.set(100, "value"); // 无错误，但创建稀疏数组
    console.log("索引 100 的值:", unsafeArray.get(100)); // "value"
    console.log("索引 50 的值:", unsafeArray.get(50)); // undefined
    
    unsafeArray.remove(200); // 无错误，但不做任何事
} catch (error) {
    console.error("运行时错误:", error);
}

// 需要手动边界检查
class SafeArray {
    constructor() {
        this.data = [];
    }
    
    set(index, value) {
        if (index < 0 || index >= this.data.length) {
            throw new Error(`索引 ${index} 越界`);
        }
        this.data[index] = value;
    }
    
    get(index) {
        if (index < 0 || index >= this.data.length) {
            throw new Error(`索引 ${index} 越界`);
        }
        return this.data[index];
    }
}
```

```swift !! swift
// Swift：编译时内存安全
struct SafeArray {
    private var data: [Int] = []
    
    mutating func set(_ value: Int, at index: Int) {
        // 编译时边界检查
        guard index >= 0 && index < data.count else {
            fatalError("索引 \(index) 越界")
        }
        data[index] = value
    }
    
    func get(_ index: Int) -> Int {
        // 编译时边界检查
        guard index >= 0 && index < data.count else {
            fatalError("索引 \(index) 越界")
        }
        return data[index]
    }
    
    mutating func append(_ value: Int) {
        data.append(value)
    }
    
    var count: Int {
        return data.count
    }
}

var safeArray = SafeArray()
safeArray.append(1)
safeArray.append(2)
safeArray.append(3)

// 编译时安全
print("索引 1 的值:", safeArray.get(1)) // 2

// 这会导致编译时错误如果我们尝试访问越界
// let value = safeArray.get(10) // 编译错误

// 可选类型用于安全访问
extension SafeArray {
    func safeGet(_ index: Int) -> Int? {
        guard index >= 0 && index < data.count else {
            return nil
        }
        return data[index]
    }
}

if let value = safeArray.safeGet(1) {
    print("安全值:", value)
} else {
    print("索引越界")
}
```
</UniversalEditor>

### 内存访问模式

<UniversalEditor title="内存访问模式" compare={true}>
```javascript !! js
// JavaScript：动态内存分配
class MemoryIntensive {
    constructor() {
        this.largeArray = new Array(1000000).fill(0);
        this.objects = [];
    }
    
    addObject() {
        // 动态分配 - 无法控制内存布局
        this.objects.push({
            id: this.objects.length,
            data: new Array(1000).fill(Math.random())
        });
    }
    
    removeObject(index) {
        // 需要手动清理
        if (index >= 0 && index < this.objects.length) {
            this.objects.splice(index, 1);
        }
    }
    
    // 可能出现内存碎片
    processData() {
        const results = [];
        for (let i = 0; i < this.largeArray.length; i += 1000) {
            results.push(this.largeArray.slice(i, i + 1000));
        }
        return results;
    }
}

const memoryIntensive = new MemoryIntensive();

// 内存使用监控（近似）
console.log("初始内存使用");
for (let i = 0; i < 100; i++) {
    memoryIntensive.addObject();
}

console.log("添加对象后");
memoryIntensive.removeObject(50);

console.log("移除对象后");
// 手动垃圾回收提示（不保证）
if (global.gc) {
    global.gc();
}
```

```swift !! swift
// Swift：可预测的内存布局和分配
struct MemoryIntensive {
    private var largeArray: [Int]
    private var objects: [DataObject]
    
    init() {
        self.largeArray = Array(repeating: 0, count: 1_000_000)
        self.objects = []
    }
    
    mutating func addObject() {
        // 连续内存分配
        let newObject = DataObject(
            id: objects.count,
            data: Array(repeating: Int.random(in: 0...1000), count: 1000)
        )
        objects.append(newObject)
    }
    
    mutating func removeObject(at index: Int) {
        // 自动清理
        guard index >= 0 && index < objects.count else { return }
        objects.remove(at: index)
    }
    
    // 高效的内存访问模式
    func processData() -> [[Int]] {
        var results: [[Int]] = []
        results.reserveCapacity(largeArray.count / 1000) // 预分配
        
        for i in stride(from: 0, to: largeArray.count, by: 1000) {
            let end = min(i + 1000, largeArray.count)
            results.append(Array(largeArray[i..<end]))
        }
        return results
    }
}

struct DataObject {
    let id: Int
    let data: [Int]
}

var memoryIntensive = MemoryIntensive()

// 内存使用是可预测的
print("初始内存使用")
for i in 0..<100 {
    memoryIntensive.addObject()
}

print("添加对象后")
memoryIntensive.removeObject(at: 50)

print("移除对象后")
// 自动内存管理
```
</UniversalEditor>

## 性能优化

### 编译器优化

<UniversalEditor title="编译器优化" compare={true}>
```javascript !! js
// JavaScript：运行时优化
class OptimizedCalculator {
    constructor() {
        this.cache = new Map();
    }
    
    // JIT 优化潜力
    calculateSum(numbers) {
        let sum = 0;
        for (let i = 0; i < numbers.length; i++) {
            sum += numbers[i];
        }
        return sum;
    }
    
    // 昂贵操作的缓存
    expensiveCalculation(input) {
        if (this.cache.has(input)) {
            return this.cache.get(input);
        }
        
        // 模拟昂贵计算
        let result = 0;
        for (let i = 0; i < 1000000; i++) {
            result += Math.sqrt(i) * Math.sin(i);
        }
        
        this.cache.set(input, result);
        return result;
    }
    
    // 内联优化潜力
    inlineCalculation(a, b, c) {
        return a * b + c;
    }
}

const calculator = new OptimizedCalculator();

// 性能测量
console.time('sum calculation');
const sum = calculator.calculateSum(Array.from({length: 1000000}, (_, i) => i));
console.timeEnd('sum calculation');

console.time('expensive calculation');
const result = calculator.expensiveCalculation(42);
console.timeEnd('expensive calculation');
```

```swift !! swift
// Swift：编译时优化
struct OptimizedCalculator {
    private var cache: [Int: Double] = [:]
    
    // 编译器可以优化循环
    func calculateSum(_ numbers: [Int]) -> Int {
        var sum = 0
        for number in numbers {
            sum += number
        }
        return sum
    }
    
    // 内联优化
    @inlinable
    func inlineCalculation(a: Int, b: Int, c: Int) -> Int {
        return a * b + c
    }
    
    // 值语义的缓存
    mutating func expensiveCalculation(_ input: Int) -> Double {
        if let cached = cache[input] {
            return cached
        }
        
        // 模拟昂贵计算
        var result: Double = 0
        for i in 0..<1_000_000 {
            result += sqrt(Double(i)) * sin(Double(i))
        }
        
        cache[input] = result
        return result
    }
}

var calculator = OptimizedCalculator()

// 性能测量
let startTime = CFAbsoluteTimeGetCurrent()
let sum = calculator.calculateSum(Array(0..<1_000_000))
let endTime = CFAbsoluteTimeGetCurrent()
print("求和计算时间: \((endTime - startTime) * 1000)ms")

let startTime2 = CFAbsoluteTimeGetCurrent()
let result = calculator.expensiveCalculation(42)
let endTime2 = CFAbsoluteTimeGetCurrent()
print("昂贵计算时间: \((endTime2 - startTime2) * 1000)ms")
```
</UniversalEditor>

### 内存布局优化

<UniversalEditor title="内存布局优化" compare={true}>
```javascript !! js
// JavaScript：无法控制内存布局
class UnoptimizedData {
    constructor() {
        this.id = 0;
        this.name = "";
        this.email = "";
        this.age = 0;
        this.isActive = false;
        this.lastLogin = null;
        this.preferences = {};
    }
}

// 内存布局由 JavaScript 引擎决定
const users = [];
for (let i = 0; i < 10000; i++) {
    users.push(new UnoptimizedData());
}

// 无法控制对象属性排序
// 无法控制内存对齐
// 无法控制缓存局部性

console.log("创建了", users.length, "个用户对象");
console.log("内存布局依赖于引擎");
```

```swift !! swift
// Swift：控制内存布局
struct OptimizedData {
    // 连续内存布局
    let id: Int64
    let age: Int32
    let isActive: Bool
    let name: String
    let email: String
    let lastLogin: Date?
    let preferences: [String: String]
}

// 内存布局是可预测和优化的
var users: [OptimizedData] = []
users.reserveCapacity(10_000) // 预分配内存

for i in 0..<10_000 {
    let user = OptimizedData(
        id: Int64(i),
        age: Int32.random(in: 18...80),
        isActive: Bool.random(),
        name: "User\(i)",
        email: "user\(i)@example.com",
        lastLogin: Date(),
        preferences: [:]
    )
    users.append(user)
}

print("创建了 \(users.count) 个用户对象")
print("内存布局是可预测和优化的")

// 数组结构模式以获得更好的缓存局部性
struct UserData {
    var ids: [Int64]
    var ages: [Int32]
    var isActive: [Bool]
    var names: [String]
    
    init(capacity: Int) {
        ids = []
        ages = []
        isActive = []
        names = []
        
        ids.reserveCapacity(capacity)
        ages.reserveCapacity(capacity)
        isActive.reserveCapacity(capacity)
        names.reserveCapacity(capacity)
    }
}

var userData = UserData(capacity: 10_000)
// 批量操作的更好缓存局部性
```
</UniversalEditor>

## 分析和分析

### 性能测量

<UniversalEditor title="性能测量" compare={true}>
```javascript !! js
// JavaScript：性能测量
class PerformanceProfiler {
    constructor() {
        this.metrics = new Map();
    }
    
    startTimer(name) {
        this.metrics.set(name, {
            startTime: performance.now(),
            endTime: null,
            duration: null
        });
    }
    
    endTimer(name) {
        const metric = this.metrics.get(name);
        if (metric) {
            metric.endTime = performance.now();
            metric.duration = metric.endTime - metric.startTime;
        }
    }
    
    getMetrics() {
        const results = {};
        for (const [name, metric] of this.metrics) {
            results[name] = metric.duration;
        }
        return results;
    }
    
    // 内存使用测量（近似）
    getMemoryUsage() {
        if (performance.memory) {
            return {
                used: performance.memory.usedJSHeapSize,
                total: performance.memory.totalJSHeapSize,
                limit: performance.memory.jsHeapSizeLimit
            };
        }
        return null;
    }
}

const profiler = new PerformanceProfiler();

// 分析不同操作
profiler.startTimer('array_creation');
const largeArray = Array.from({length: 1000000}, (_, i) => i);
profiler.endTimer('array_creation');

profiler.startTimer('array_processing');
const sum = largeArray.reduce((acc, val) => acc + val, 0);
profiler.endTimer('array_processing');

console.log('性能指标:', profiler.getMetrics());
console.log('内存使用:', profiler.getMemoryUsage());
```

```swift !! swift
// Swift：性能测量
import Foundation

class PerformanceProfiler {
    private var metrics: [String: (startTime: CFAbsoluteTime, endTime: CFAbsoluteTime?, duration: CFTimeInterval?)] = [:]
    
    func startTimer(_ name: String) {
        metrics[name] = (CFAbsoluteTimeGetCurrent(), nil, nil)
    }
    
    func endTimer(_ name: String) {
        guard var metric = metrics[name] else { return }
        metric.endTime = CFAbsoluteTimeGetCurrent()
        metric.duration = metric.endTime! - metric.startTime
        metrics[name] = metric
    }
    
    func getMetrics() -> [String: CFTimeInterval] {
        var results: [String: CFTimeInterval] = [:]
        for (name, metric) in metrics {
            if let duration = metric.duration {
                results[name] = duration
            }
        }
        return results
    }
    
    // 内存使用测量
    func getMemoryUsage() -> (used: Int, total: Int) {
        var info = mach_task_basic_info()
        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4
        
        let kerr: kern_return_t = withUnsafeMutablePointer(to: &info) {
            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
                task_info(mach_task_self_,
                         task_flavor_t(MACH_TASK_BASIC_INFO),
                         $0,
                         &count)
            }
        }
        
        if kerr == KERN_SUCCESS {
            return (Int(info.resident_size), Int(info.virtual_size))
        }
        return (0, 0)
    }
}

let profiler = PerformanceProfiler()

// 分析不同操作
profiler.startTimer("array_creation")
let largeArray = Array(0..<1_000_000)
profiler.endTimer("array_creation")

profiler.startTimer("array_processing")
let sum = largeArray.reduce(0, +)
profiler.endTimer("array_processing")

print("性能指标:", profiler.getMetrics())
print("内存使用:", profiler.getMemoryUsage())
```
</UniversalEditor>

## 关键要点

### Swift 内存管理优势
1. **可预测性能**：ARC 提供一致的内存管理开销
2. **编译时安全**：内存安全检查防止常见错误
3. **值类型**：消除许多内存管理问题
4. **自动清理**：无需手动内存管理
5. **性能优化**：编译器可以优化内存访问模式
6. **内存布局控制**：可预测和高效的内存布局

### 与 JavaScript 的关键差异
1. **内存管理**：ARC vs 垃圾回收
2. **性能可预测性**：一致 vs 可变性能
3. **内存安全**：编译时 vs 运行时安全
4. **值类型**：完全支持 vs 有限支持
5. **内存布局**：可控 vs 引擎依赖
6. **优化**：编译时 vs 运行时优化

### 最佳实践
1. **尽可能使用值类型**以获得更好的性能
2. **使用弱引用和无主引用避免循环引用**
3. **分析内存使用**以识别瓶颈
4. **优化内存布局**以提高缓存局部性
5. **使用适当的数据结构**以提高内存效率
6. **在性能关键代码中监控 ARC 行为**

### 性能优化技巧
1. **在已知大小时预分配集合**
2. **对小的、频繁复制的数据使用结构体**
3. **在循环中避免不必要的对象创建**
4. **在优化前进行分析和测量**
5. **使用适当的引用类型**（强引用、弱引用、无主引用）
6. **考虑高频分配的内存池**

### 下一步
在下一个模块中，我们将探索 Swift 的系统编程能力，包括低级内存访问、C 互操作性和系统级编程，将它们与 JavaScript 在这些领域的局限性进行对比。 